掌握时间序列数据：Python与InfluxDB集成综合指南

            docker run --name influxdb -p 8086:8086 influxdb:latest
            

              
                Copy
              
            
          

            pip install influxdb-client
            

              
                Copy
              
            
          

            import influxdb_client
from influxdb_client.client.write_api import SYNCHRONOUS

# --- Connection Details ---
url = "http://localhost:8086"
token = "YOUR_SUPER_SECRET_TOKEN"  # Replace with your actual token
org = "my-org"
bucket = "my-bucket"

# --- Instantiate the Client ---
client = influxdb_client.InfluxDBClient(url=url, token=token, org=org)

# --- Get the Write API ---
# SYNCHRONOUS mode writes data immediately. For high-throughput, consider ASYNCHRONOUS.
write_api = client.write_api(write_options=SYNCHRONOUS)

print("Successfully connected to InfluxDB!")
            

              
                Copy
              
            
          

            from influxdb_client import Point
import time

# Create a data point using the fluent API
point = (
    Point("system_metrics")
    .tag("host", "server-alpha")
    .tag("region", "eu-central-1")
    .field("cpu_load_percent", 12.34)
    .field("memory_usage_mb", 567.89)
    .time(int(time.time_ns())) # Use nanosecond precision timestamp
)

# Write the point to the bucket
write_api.write(bucket=bucket, org=org, record=point)

print(f"Wrote a single point to '{bucket}'.")
            

              
                Copy
              
            
          

            points = []

# Simulate 5 readings from two different sensors
for i in range(5):
    # Sensor 1
    point1 = (
        Point("environment")
        .tag("sensor_id", "A001")
        .tag("location", "greenhouse-1")
        .field("temperature", 25.1 + i * 0.1)
        .field("humidity", 60.5 + i * 0.2)
        .time(int(time.time_ns()) - i * 10**9) # Stagger timestamps by 1 second
    )
    points.append(point1)

    # Sensor 2
    point2 = (
        Point("environment")
        .tag("sensor_id", "B002")
        .tag("location", "greenhouse-2")
        .field("temperature", 22.8 + i * 0.15)
        .field("humidity", 55.2 - i * 0.1)
        .time(int(time.time_ns()) - i * 10**9)
    )
    points.append(point2)

# Write the entire batch of points
write_api.write(bucket=bucket, org=org, record=points)

print(f"Wrote a batch of {len(points)} points to '{bucket}'.")
            

              
                Copy
              
            
          

            import pandas as pd
import numpy as np

# Create a sample DataFrame
now = pd.Timestamp.now(tz='UTC')
dates = pd.to_datetime([now - pd.Timedelta(minutes=i) for i in range(10)])

data = {
    'price': np.random.uniform(100, 110, 10),
    'volume': np.random.randint(1000, 5000, 10),
    'symbol': 'XYZ',
    'exchange': 'GLOBALEX'
}

df = pd.DataFrame(data=data, index=dates)

# The DataFrame must have a timezone-aware DatetimeIndex
print("Sample DataFrame:")
print(df)

# Write the DataFrame to InfluxDB
# data_frame_measurement_name: The measurement name to use
# data_frame_tag_columns: Columns to be treated as tags
write_api.write(
    bucket=bucket,
    record=df,
    data_frame_measurement_name='stock_prices',
    data_frame_tag_columns=['symbol', 'exchange']
)

print(f"\nWrote DataFrame to measurement 'stock_prices' in bucket '{bucket}'.")

# Remember to close the client
client.close()
            

              
                Copy
              
            
          

            from(bucket: "my-bucket")
  |> range(start: -1h)
  |> filter(fn: (r) => r._measurement == "system_metrics")
  |> filter(fn: (r) => r.host == "server-alpha")
            

              
                Copy
              
            
          

            # --- Re-establish connection for querying ---
client = influxdb_client.InfluxDBClient(url=url, token=token, org=org)
query_api = client.query_api()

# --- Define the Flux query ---
flux_query = f'''
from(bucket: "{bucket}")
  |> range(start: -10m)
  |> filter(fn: (r) => r._measurement == "environment")
'''

# --- Execute the query ---
result_tables = query_api.query(query=flux_query, org=org)

print("Query executed. Processing results...")
            

              
                Copy
              
            
          

            # Iterate through tables
for table in result_tables:
    print(f"--- Table (series for tags: {table.records[0].values}) ---")
    # Iterate through records in each table
    for record in table.records:
        print(f"Time: {record.get_time()}, Field: {record.get_field()}, Value: {record.get_value()}")

print("\nFinished processing query results.")
            

              
                Copy
              
            
          

            flux_aggregate_query = f'''
from(bucket: "{bucket}")
  |> range(start: -1h)
  |> filter(fn: (r) => r._measurement == "environment")
  |> filter(fn: (r) => r._field == "temperature")
  |> window(every: 2m)
  |> mean()
  |> yield(name: "mean_temperature")
'''

# Execute and process
aggregated_results = query_api.query(query=flux_aggregate_query, org=org)

print("\n--- Aggregated Results (Average Temperature per 2m) ---")
for table in aggregated_results:
    for record in table.records:
        print(f"Time Window End: {record.get_time()}, Average Temp: {record.get_value():.2f}")
            

              
                Copy
              
            
          

            # --- Query stock prices into a DataFrame ---
flux_df_query = f'''
from(bucket: "{bucket}")
  |> range(start: -1h)
  |> filter(fn: (r) => r._measurement == "stock_prices")
  |> pivot(rowKey:["_time"], columnKey: ["_field"], valueColumn: "_value")
'''

# Execute the query
df_result = query_api.query_data_frame(query=flux_df_query, org=org)

# The result might have extra columns, let's clean it up
if not df_result.empty:
    df_result = df_result[['_time', 'symbol', 'price', 'volume']]
    df_result.set_index('_time', inplace=True)
    print("\n--- Query Result as Pandas DataFrame ---")
    print(df_result)
else:
    print("\nQuery returned no data.")

client.close()
            

              
                Copy
              
            
          

            pip install psutil
            

              
                Copy
              
            
          

            import influxdb_client
from influxdb_client import Point
from influxdb_client.client.write_api import SYNCHRONOUS
import psutil
import time
import socket

# --- Configuration ---
url = "http://localhost:8086"
token = "YOUR_SUPER_SECRET_TOKEN" # Replace with your token
org = "my-org"
bucket = "monitoring"

# Get the hostname to use as a tag
hostname = socket.gethostname()

# --- Main Monitoring Loop ---
def monitor_system():
    print("Starting system monitor...")
    with influxdb_client.InfluxDBClient(url=url, token=token, org=org) as client:
        write_api = client.write_api(write_options=SYNCHRONOUS)

        while True:
            try:
                # Get metrics
                cpu_percent = psutil.cpu_percent(interval=1)
                memory_percent = psutil.virtual_memory().percent

                # Create data points
                cpu_point = (
                    Point("system_stats")
                    .tag("host", hostname)
                    .field("cpu_usage_percent", float(cpu_percent))
                )
                memory_point = (
                    Point("system_stats")
                    .tag("host", hostname)
                    .field("memory_usage_percent", float(memory_percent))
                )

                # Write batch
                write_api.write(bucket=bucket, org=org, record=[cpu_point, memory_point])
                print(f"Logged CPU: {cpu_percent}%, Memory: {memory_percent}%")

                # Wait for the next interval
                time.sleep(10)

            except KeyboardInterrupt:
                print("\nMonitoring stopped by user.")
                break
            except Exception as e:
                print(f"An error occurred: {e}")
                time.sleep(10) # Wait before retrying

if __name__ == "__main__":
    # Note: You may need to create the 'monitoring' bucket in the InfluxDB UI first.
    monitor_system()
            

              
                Copy